home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1998 November / Freeware November 1998.img / dist / fw_emacs.idb / usr / freeware / share / emacs / 19.34 / lisp / ffap.el.z / ffap.el
Lisp/Scheme  |  1998-10-27  |  56KB  |  1,494 lines
  1. ;;; ffap.el --- find file or url at point
  2.  
  3. ;; Copyright (C) 1995, 1996 Free Software Foundation, Inc.
  4.  
  5. ;; Author: Michelangelo Grigni <mic@mathcs.emory.edu>
  6. ;; Created: 29 Mar 1993
  7. ;; Keywords: files, hypermedia, matching, mouse
  8. ;; X-Latest: ftp://ftp.mathcs.emory.edu:/pub/mic/emacs/
  9.  
  10. ;; This file is part of GNU Emacs.
  11.  
  12. ;; GNU Emacs is free software; you can redistribute it and/or modify
  13. ;; it under the terms of the GNU General Public License as published by
  14. ;; the Free Software Foundation; either version 2, or (at your option)
  15. ;; any later version.
  16.  
  17. ;; GNU Emacs is distributed in the hope that it will be useful,
  18. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20. ;; GNU General Public License for more details.
  21.  
  22. ;; You should have received a copy of the GNU General Public License
  23. ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  24. ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  25. ;; Boston, MA 02111-1307, USA.
  26.  
  27.  
  28. ;;; Commentary:
  29. ;;
  30. ;; Command find-file-at-point replaces find-file.  With a prefix, it
  31. ;; behaves exactly like find-file.  Without a prefix, it first tries
  32. ;; to guess a default file or url from the text around the point
  33. ;; (`ffap-require-prefix' swaps these behaviors).  This is useful for
  34. ;; following references in situations such as mail or news buffers,
  35. ;; README's, MANIFEST's, and so on.  Submit bugs or suggestions with
  36. ;; M-x ffap-bug.
  37. ;;
  38. ;; For the default installation, byte-compile ffap.el somewhere in
  39. ;; your `load-path' and add these two lines to your .emacs file:
  40. ;;
  41. ;; (require 'ffap)                      ; load the package
  42. ;; (ffap-bindings)                      ; do default key bindings
  43. ;;
  44. ;; ffap-bindings makes the following global key bindings:
  45. ;;
  46. ;; C-x C-f       find-file-at-point (abbreviated as ffap)
  47. ;; C-x 4 f       ffap-other-window
  48. ;; C-x 5 f       ffap-other-frame
  49. ;; S-mouse-3     ffap-at-mouse
  50. ;;
  51. ;; ffap-bindings also adds hooks to make the following local bindings
  52. ;; in vm, gnus, and rmail:
  53. ;;
  54. ;; M-l         ffap-next, or ffap-gnus-next in gnus
  55. ;; M-m         ffap-menu, or ffap-gnus-menu in gnus
  56. ;;
  57. ;; If you do not like these bindings, modify the variable
  58. ;; `ffap-bindings', or write your own.
  59. ;;
  60. ;; If you use ange-ftp, browse-url, complete, efs, or w3, it is best
  61. ;; to load or autoload them before ffap.  If you use ff-paths, load it
  62. ;; afterwards.  Try apropos {C-h a ffap RET} to get a list of the many
  63. ;; option variables.  In particular, if ffap is slow, try these:
  64. ;;
  65. ;; (setq ffap-alist nil)                ; faster, dumber prompting
  66. ;; (setq ffap-machine-p-known 'accept)  ; no pinging
  67. ;; (setq ffap-url-regexp nil)           ; disable url features in ffap
  68. ;;
  69. ;; ffap uses w3 (if found) or else browse-url to fetch url's.  For
  70. ;; a hairier `ffap-url-fetcher', try ffap-url.el (same ftp site).
  71. ;; Also, you can add `ffap-menu-rescan' to various hooks to fontify
  72. ;; the file and url references within a buffer.
  73.  
  74. ;;; Todo list:
  75. ;; * recognize paths inside /usr/bin:/bin:/etc, ./ffap.el:80:
  76. ;; * let "/path/file#key" jump to key (offset or regexp) in /path/file
  77. ;; * find file of symbol if TAGS is loaded (like above)
  78. ;; * break up long menus into multiple panes (like imenu?)
  79. ;; * notice node in "(dired)Virtual Dired" (handle the space?)
  80. ;; * notice "machine.dom blah blah blah path/file" (how?)
  81. ;; * if w3 becomes standard, could rewrite to use its functions
  82. ;; * regexp options for ffap-string-at-point, like font-lock (MCOOK)
  83. ;; * v19: could replace `ffap-locate-file' with a quieter `locate-library'
  84. ;; * support for custom.el
  85. ;; + handle "$(HOME)" in Makefiles?
  86. ;; + modify `font-lock-keywords' to do fontification
  87.  
  88.  
  89. ;;; Code:
  90.  
  91. (provide 'ffap)
  92.  
  93. ;; Versions: This file is tested with Emacs 19.30.  It mostly works
  94. ;; with XEmacs, but get ffap-xe.el for the popup menu.  Emacs 18 is
  95. ;; now abandoned (get ffap-15.el instead).
  96.  
  97. (defvar ffap-xemacs (and (string-match "X[Ee]macs" emacs-version) t)
  98.   "Whether ffap thinks it is running under XEmacs.")
  99.  
  100.  
  101.  
  102. ;;; User Variables:
  103.  
  104. ;; This function is used inside defvars:
  105. (defun ffap-soft-value (name &optional default)
  106.   "Return value of symbol with NAME, if it is interned.
  107. Otherwise return nil (or the optional DEFAULT value)."
  108.   ;; Bug: (ffap-soft-value "nil" 5) --> 5
  109.   (let ((sym (intern-soft name)))
  110.     (if (and sym (boundp sym)) (symbol-value sym) default)))
  111.  
  112.  
  113. (defvar ffap-ftp-regexp
  114.   (and
  115.    (or (featurep 'ange-ftp)
  116.        (featurep 'efs)
  117.        (and (boundp 'file-name-handler-alist) ; v19
  118.         (or (rassq 'ange-ftp-hook-function file-name-handler-alist)
  119.         (rassq 'efs-file-handler-function file-name-handler-alist))))
  120.    ;; Apparently this is good enough for both ange-ftp and efs:
  121.    "\\`/[^/:]+:")
  122.   "*Treat paths matching this as remote ftp paths.  Nil to disable.
  123. Nil also disables the generation of such paths by ffap.")
  124.  
  125. (defvar ffap-url-unwrap-local t
  126.   "*If non-nil, convert \"file:\" url to local path before prompting.")
  127.  
  128. (defvar ffap-url-unwrap-remote t
  129.   "*If non-nil, convert \"ftp:\" url to remote path before prompting.
  130. This is ignored if `ffap-ftp-regexp' is nil.")
  131.  
  132. (defvar ffap-ftp-default-user
  133.   (if (or (equal (ffap-soft-value "ange-ftp-default-user") "anonymous")
  134.       (equal (ffap-soft-value "efs-default-user") "anonymous"))
  135.       nil
  136.     "anonymous")
  137.   "*User name in ftp paths generated by `ffap-host-to-path'.
  138. Nil to rely on `efs-default-user' or `ange-ftp-default-user'.")
  139.  
  140. (defvar ffap-rfs-regexp
  141.   ;; Remote file access built into file system?  HP rfa or Andrew afs:
  142.   "\\`/\\(afs\\|net\\)/."
  143.   ;; afs only: (and (file-exists-p "/afs") "\\`/afs/.")
  144.   "*Matching paths are treated as remote.  Nil to disable.")
  145.  
  146. (defvar ffap-url-regexp
  147.   ;; Could just use `url-nonrelative-link' of w3, if loaded.
  148.   ;; This regexp is not exhaustive, it just matches common cases.
  149.   (concat
  150.    "\\`\\("
  151.    "news\\(post\\)?:\\|mailto:\\|file:" ; no host ok
  152.    "\\|"
  153.    "\\(ftp\\|http\\|telnet\\|gopher\\|www\\|wais\\)://" ; needs host
  154.    "\\)."                ; require one more character
  155.    )
  156.    "Regexp matching url's.  Nil to disable url features in ffap.")
  157.  
  158. (defvar ffap-foo-at-bar-prefix "mailto"
  159.   "*Presumed url prefix type of strings like \"<foo.9z@bar>\".
  160. Sensible values are nil, \"news\", or \"mailto\".")
  161.  
  162.  
  163. ;;; Peanut Gallery:
  164. ;;
  165. ;; Users of ffap occasionally suggest new features.  If I consider
  166. ;; those features interesting but not clear winners (a matter of
  167. ;; personal taste) I try to leave options to enable them.  Read
  168. ;; through this section for features that you like, put an appropriate
  169. ;; enabler in your .emacs file.
  170.  
  171. (defvar ffap-dired-wildcards nil    ; "[*?][^/]*$"
  172.   ;; Suggestion from RHOGEE, 07 Jul 1994.  Disabled, dired is still
  173.   ;; available by "C-x C-d <pattern>", and valid filenames may
  174.   ;; sometimes contain wildcard characters.
  175.   "*A regexp matching filename wildcard characters, or nil.
  176. If `find-file-at-point' gets a filename matching this pattern,
  177. it passes it on to `dired' instead of `find-file'.")
  178.  
  179. (defvar ffap-newfile-prompt nil        ; t
  180.   ;; Suggestion from RHOGEE, 11 Jul 1994.  Disabled, I think this is
  181.   ;; better handled by `find-file-not-found-hooks'.
  182.   "*Whether `find-file-at-point' prompts about a nonexistent file.")
  183.  
  184. (defvar ffap-require-prefix nil
  185.   ;; Suggestion from RHOGEE, 20 Oct 1994.
  186.   "*If set, reverses the prefix argument to `find-file-at-point'.
  187. This is nil so neophytes notice ffap.  Experts may prefer to disable
  188. ffap most of the time.")
  189.  
  190. (defvar ffap-file-finder 'find-file
  191.   "*The command called by `find-file-at-point' to find a file.")
  192. (put 'ffap-file-finder 'risky-local-variable t)
  193.  
  194. (defvar ffap-url-fetcher
  195.   (cond ((fboundp 'w3-fetch) 'w3-fetch)
  196.     ((fboundp 'browse-url-netscape) 'browse-url-netscape)
  197.     (t 'w3-fetch))
  198.   ;; Remote control references:
  199.   ;; http://www.ncsa.uiuc.edu/SDG/Software/XMosaic/remote-control.html
  200.   ;; http://home.netscape.com/newsref/std/x-remote.html
  201.   "*A function of one argument, called by ffap to fetch an URL.
  202. Reasonable choices are `w3-fetch' or `browse-url-netscape'.
  203. For a fancier alternative, get ffap-url.el.")
  204. (put 'ffap-url-fetcher 'risky-local-variable t)
  205.  
  206.  
  207. ;;; Command ffap-next:
  208. ;;
  209. ;; Original ffap-next-url (URL's only) from RPECK 30 Mar 1995.  Since
  210. ;; then, broke it up into ffap-next-guess (noninteractive) and
  211. ;; ffap-next (a command).  It now work on files as well as url's.
  212.  
  213. (defvar ffap-next-regexp
  214.   ;; If you want ffap-next to find URL's only, try this:
  215.   ;; (and ffap-url-regexp (string-match "\\\\`" ffap-url-regexp)
  216.   ;;      (concat "\\<" (substring ffap-url-regexp 2))))
  217.   ;;
  218.   ;; It pays to put a big fancy regexp here, since ffap-guesser is
  219.   ;; much more time-consuming than regexp searching:
  220.   "[/:.~a-zA-Z]/\\|@[a-zA-Z][-a-zA-Z0-9]*\\."
  221.   "*Regular expression governing movements of `ffap-next'.")
  222.  
  223. (defvar ffap-next-guess nil "Last value returned by `ffap-next-guess'.")
  224. (defun ffap-next-guess (&optional back lim)
  225.   "Move point to next file or url, and return it as a string.
  226. If nothing is found, leave point at limit and return nil.
  227. Optional BACK argument makes search backwards.
  228. Optional LIM argument limits the search.
  229. Only considers strings that match `ffap-next-regexp'."
  230.   (or lim (setq lim (if back (point-min) (point-max))))
  231.   (let (guess)
  232.     (while (not (or guess (eq (point) lim)))
  233.       (funcall (if back 're-search-backward 're-search-forward)
  234.            ffap-next-regexp lim 'move)
  235.       (setq guess (ffap-guesser)))
  236.     ;; Go to end, so we do not get same guess twice:
  237.     (goto-char (nth (if back 0 1) ffap-string-at-point-region))
  238.     (setq ffap-next-guess guess)))
  239.  
  240. ;;;###autoload
  241. (defun ffap-next (&optional back wrap)
  242.   "Search buffer for next file or url, and run ffap.
  243. Optional argument BACK says to search backwards.
  244. Optional argument WRAP says to try wrapping around if necessary.
  245. Interactively: use a single prefix to search backwards,
  246. double prefix to wrap forward, triple to wrap backwards.
  247. Actual search is done by `ffap-next-guess'."
  248.   (interactive
  249.    (cdr (assq (prefix-numeric-value current-prefix-arg)
  250.           '((1) (4 t) (16 nil t) (64 t t)))))
  251.   (let ((pt (point))
  252.     (guess (ffap-next-guess back)))
  253.     ;; Try wraparound if necessary:
  254.     (and (not guess) wrap
  255.      (goto-char (if back (point-max) (point-min)))
  256.      (setq guess (ffap-next-guess back pt)))
  257.     (if guess
  258.     (progn
  259.       (sit-for 0)            ; display point movement
  260.       (find-file-at-point (ffap-prompter guess)))
  261.       (goto-char pt)            ; restore point
  262.       (message "No %sfiles or URL's found."
  263.            (if wrap "" "more ")))))
  264.  
  265. (defun ffap-next-url (&optional back wrap)
  266.   "Like `ffap-next', but search with `ffap-url-regexp'."
  267.   (interactive)
  268.   (let ((ffap-next-regexp ffap-url-regexp))
  269.     (if (interactive-p)
  270.     (call-interactively 'ffap-next)
  271.       (ffap-next back wrap))))
  272.  
  273.  
  274. ;;; Remote machines and paths:
  275.  
  276. (defun ffap-replace-path-component (fullname name)
  277.   "In remote FULLNAME, replace path with NAME.  May return nil."
  278.   ;; Use ange-ftp or efs if loaded, but do not load them otherwise.
  279.   (let (found)
  280.     (mapcar
  281.      (function (lambda (sym) (and (fboundp sym) (setq found sym))))
  282.      '(
  283.        efs-replace-path-component
  284.        ange-ftp-replace-path-component
  285.        ange-ftp-replace-name-component
  286.        ))
  287.     (and found
  288.      (fset 'ffap-replace-path-component found)
  289.      (funcall found fullname name))))
  290. ;; (ffap-replace-path-component "/who@foo.com:/whatever" "/new")
  291.  
  292. (defun ffap-file-exists-string (file)
  293.   ;; With certain packages (ange-ftp, jka-compr?) file-exists-p
  294.   ;; sometimes returns a nicer string than it is given.  Otherwise, it
  295.   ;; just returns nil or t.
  296.   "Return FILE \(maybe modified\) if it exists, else nil."
  297.   (and file                ; quietly reject nil
  298.        (let ((exists (file-exists-p file)))
  299.      (and exists (if (stringp exists) exists file)))))
  300.  
  301. ;; I cannot decide a "best" strategy here, so these are variables.  In
  302. ;; particular, if `Pinging...' is broken or takes too long on your
  303. ;; machine, try setting these all to accept or reject.
  304. (defvar ffap-machine-p-local 'reject    ; this happens often
  305.   "*A symbol, one of: ping, accept, reject.
  306. What `ffap-machine-p' does with hostnames that have no domain.")
  307. (defvar ffap-machine-p-known 'ping    ; 'accept for speed
  308.   "*A symbol, one of: ping, accept, reject.
  309. What `ffap-machine-p' does with hostnames that have a known domain
  310. \(see mail-extr.el for the known domains\).")
  311. (defvar ffap-machine-p-unknown 'reject
  312.   "*A symbol, one of: ping, accept, reject.
  313. What `ffap-machine-p' does with hostnames that have an unknown domain
  314. \(see mail-extr.el for the known domains\).")
  315.  
  316. (defun ffap-what-domain (domain)
  317.   ;; Like what-domain in mail-extr.el, returns string or nil.
  318.   (require 'mail-extr)
  319.   (defvar mail-extr-all-top-level-domains
  320.     (ffap-soft-value "all-top-level-domains" obarray)) ; XEmacs, old Emacs
  321.   (get (intern-soft (downcase domain) mail-extr-all-top-level-domains)
  322.        'domain-name))
  323.  
  324. (defun ffap-machine-p (host &optional service quiet strategy)
  325.   "Decide whether HOST is the name of a real, reachable machine.
  326. Depending on the domain (none, known, or unknown), follow the strategy
  327. named by the variable `ffap-machine-p-local', `ffap-machine-p-known',
  328. or `ffap-machine-p-unknown'.  Pinging uses `open-network-stream'.
  329. Optional SERVICE specifies the port used \(default \"discard\"\).
  330. Optional QUIET flag suppresses the \"Pinging...\" message.
  331. Optional STRATEGY overrides the three variables above.
  332. Returned values:
  333.  t      means that HOST answered.
  334. 'accept means the relevant variable told us to accept.
  335. \"mesg\"  means HOST exists, but does not respond for some reason."
  336.   ;; Try some (Emory local):
  337.   ;; (ffap-machine-p "ftp" nil nil 'ping)
  338.   ;; (ffap-machine-p "nonesuch" nil nil 'ping)
  339.   ;; (ffap-machine-p "ftp.mathcs.emory.edu" nil nil 'ping)
  340.   ;; (ffap-machine-p "mathcs" 5678 nil 'ping)
  341.   ;; (ffap-machine-p "foo.bonk" nil nil 'ping)
  342.   ;; (ffap-machine-p "foo.bonk.com" nil nil 'ping)
  343.   (if (or (string-match "[^-a-zA-Z0-9.]" host) ; Illegal chars (?)
  344.       (not (string-match "[^0-9]" host))) ; 1: a number? 2: quick reject
  345.       nil
  346.     (let* ((domain
  347.         (and (string-match "\\.[^.]*$" host)
  348.          (downcase (substring host (1+ (match-beginning 0))))))
  349.        (what-domain (if domain (ffap-what-domain domain) "Local")))
  350.       (or strategy
  351.       (setq strategy
  352.         (cond ((not domain) ffap-machine-p-local)
  353.               ((not what-domain) ffap-machine-p-unknown)
  354.               (t ffap-machine-p-known))))
  355.       (cond
  356.        ((eq strategy 'accept) 'accept)
  357.        ((eq strategy 'reject) nil)
  358.        ;; assume (eq strategy 'ping)
  359.        (t
  360.     (or quiet
  361.         (if (stringp what-domain)
  362.         (message "Pinging %s (%s)..." host what-domain)
  363.           (message "Pinging %s ..." host)))
  364.     (condition-case error
  365.         (progn
  366.           (delete-process
  367.            (open-network-stream
  368.         "ffap-machine-p" nil host (or service "discard")))
  369.           t)
  370.       (error
  371.        (let ((mesg (car (cdr error))))
  372.          (cond
  373.           ;; v18:
  374.           ((string-match "^Unknown host" mesg) nil)
  375.           ((string-match "not responding$" mesg) mesg)
  376.           ;; v19:
  377.           ;; (file-error "connection failed" "permission denied"
  378.           ;;             "nonesuch" "ffap-machine-p")
  379.           ;; (file-error "connection failed" "host is unreachable"
  380.           ;;         "gopher.house.gov" "ffap-machine-p")
  381.           ;; (file-error "connection failed" "address already in use"
  382.           ;;         "ftp.uu.net" "ffap-machine-p")
  383.           ((equal mesg "connection failed")
  384.            (if (equal (nth 2 error) "permission denied")
  385.            nil            ; host does not exist
  386.          ;; Other errors mean the host exists:
  387.          (nth 2 error)))
  388.           ;; Could be "Unknown service":
  389.           (t (signal (car error) (cdr error))))))))))))
  390.  
  391. (defun ffap-file-remote-p (filename)
  392.   "If FILENAME looks remote, return it \(maybe slightly improved\)."
  393.   ;; (ffap-file-remote-p "/user@foo.bar.com:/pub")
  394.   ;; (ffap-file-remote-p "/cssun.mathcs.emory.edu://path")
  395.   ;; (ffap-file-remote-p "/ffap.el:80")
  396.   (or (and ffap-ftp-regexp
  397.        (string-match ffap-ftp-regexp filename)
  398.        ;; Convert "/host.com://path" to "/host:/path", to handle a dieing
  399.        ;; practice of advertising ftp paths as "host.dom://path".
  400.        (if (string-match "//" filename)
  401.            ;; (replace-match "/" nil nil filename)
  402.            (concat (substring filename 0 (1+ (match-beginning 0)))
  403.                (substring filename (match-end 0)))
  404.          filename))
  405.       (and ffap-rfs-regexp
  406.        (string-match ffap-rfs-regexp filename)
  407.        filename)))
  408.  
  409. (defun ffap-machine-at-point nil
  410.   "Return machine name at point if it exists, or nil."
  411.   (let ((mach (ffap-string-at-point 'machine)))
  412.     (and (ffap-machine-p mach) mach)))
  413.  
  414. (defsubst ffap-host-to-path (host)
  415.   "Convert HOST to something like \"/anonymous@HOST:\".
  416. Looks at `ffap-ftp-default-user', returns \"\" for \"localhost\"."
  417.   (if (equal host "localhost") ""
  418.     (concat "/"
  419.         ffap-ftp-default-user (and ffap-ftp-default-user "@")
  420.         host ":")))
  421.  
  422. (defun ffap-fixup-machine (mach)
  423.   ;; Convert a hostname into an url, an ftp path, or nil.
  424.   (cond
  425.    ((not (and ffap-url-regexp (stringp mach))) nil)
  426.    ;; gopher.well.com
  427.    ((string-match "\\`gopher[-.]" mach)    ; or "info"?
  428.     (concat "gopher://" mach "/"))
  429.    ;; www.ncsa.uiuc.edu
  430.    ((and (string-match "\\`w\\(ww\\|eb\\)[-.]" mach))
  431.     (concat "http://" mach "/"))
  432.    ;; More cases?  Maybe "telnet:" for archie?
  433.    (ffap-ftp-regexp (ffap-host-to-path mach))
  434.    ))
  435.  
  436. (defun ffap-newsgroup-p (string)
  437.   "Return STRING if it looks like a newsgroup name, else nil."
  438.   (and
  439.    (string-match ffap-newsgroup-regexp string)
  440.    (let ((htbs '(gnus-active-hashtb gnus-newsrc-hashtb gnus-killed-hashtb))
  441.      (heads ffap-newsgroup-heads)
  442.      htb ret)
  443.      (while htbs
  444.        (setq htb (car htbs) htbs (cdr htbs))
  445.        (condition-case nil
  446.        (progn
  447.          ;; errs: htb symbol may be unbound, or not a hash-table.
  448.          ;; gnus-gethash is just a macro for intern-soft.
  449.          (and (intern-soft string (symbol-value htb))
  450.           (setq ret string htbs nil))
  451.          ;; If we made it this far, gnus is running, so ignore "heads":
  452.          (setq heads nil))
  453.      (error nil)))
  454.      (or ret (not heads)
  455.      (let ((head (string-match "\\`\\([a-z]+\\)\\." string)))
  456.        (and head (setq head (substring string 0 (match-end 1)))
  457.         (member head heads)
  458.         (setq ret string))))
  459.      ;; Is there ever a need to modify string as a newsgroup name?
  460.      ret)))
  461. (defvar ffap-newsgroup-regexp "^[a-z]+\\.[-+a-z_0-9.]+$"
  462.   "Strings not matching this fail `ffap-newsgroup-p'.")
  463. (defvar ffap-newsgroup-heads        ; entirely inadequate
  464.   '("alt" "comp" "gnu" "misc" "news" "sci" "soc" "talk")
  465.   "Used by `ffap-newsgroup-p' if gnus is not running.")
  466.  
  467. (defsubst ffap-url-p (string)
  468.   "If STRING looks like an url, return it (maybe improved), else nil."
  469.   (let ((case-fold-search t))
  470.     (and ffap-url-regexp (string-match ffap-url-regexp string)
  471.      ;; I lied, no improvement:
  472.      string)))
  473.  
  474. ;; Broke these out of ffap-fixup-url, for use of ffap-url package.
  475. (defsubst ffap-url-unwrap-local (url)
  476.   "Return URL as a local file, or nil.  Ignores `ffap-url-regexp'."
  477.   (and (string-match "\\`\\(file\\|ftp\\):/?\\([^/]\\|\\'\\)" url)
  478.        (substring url (1+ (match-end 1)))))
  479. (defsubst ffap-url-unwrap-remote (url)
  480.   "Return URL as a remote file, or nil.  Ignores `ffap-url-regexp'."
  481.   (and (string-match "\\`\\(ftp\\|file\\)://\\([^:/]+\\):?\\(/.*\\)" url)
  482.        (concat
  483.     (ffap-host-to-path (substring url (match-beginning 2) (match-end 2)))
  484.     (substring url (match-beginning 3) (match-end 3)))))
  485. ;; Test: (ffap-url-unwrap-remote "ftp://foo.com/bar.boz")
  486.  
  487. (defun ffap-fixup-url (url)
  488.   "Clean up URL and return it, maybe as a file name."
  489.   (cond
  490.    ((not (stringp url)) nil)
  491.    ((and ffap-url-unwrap-local (ffap-url-unwrap-local url)))
  492.    ((and ffap-url-unwrap-remote ffap-ftp-regexp
  493.      (ffap-url-unwrap-remote url)))
  494.    ;; Do not load w3 just for this:
  495.    (t (let ((normal (and (fboundp 'url-normalize-url)
  496.              (url-normalize-url url))))
  497.     ;; In case url-normalize-url is confused:
  498.     (or (and normal (not (zerop (length normal))) normal)
  499.         url)))))
  500.  
  501.  
  502. ;;; `ffap-alist':
  503. ;;
  504. ;; Search actions depending on the major-mode or extensions of the
  505. ;; current name.  Note all the little defun's could be broken out, at
  506. ;; some loss of locality.  A good example of featuritis.
  507.  
  508. ;; First, some helpers for functions in `ffap-alist':
  509.  
  510. (defvar path-separator ":")        ; for XEmacs 19.13
  511.  
  512. (defun ffap-list-env (env &optional empty)
  513.   ;; Replace this with parse-colon-path (lisp/files.el)?
  514.   "Directory list parsed from path envinronment variable ENV.
  515. Optional EMPTY is default if (getenv ENV) is undefined, and is also
  516. substituted for the first empty-string component, if there is one.
  517. Uses `path-separator' to separate the path into directories."
  518.   ;; Derived from psg-list-env in RHOGEE's ff-paths and
  519.   ;; bib-cite packages.  The `empty' argument is intended to mimic
  520.   ;; the semantics of TeX/BibTeX variables, it is substituted for
  521.   ;; any empty string entry.
  522.   (if (or empty (getenv env))        ; should return something
  523.       (let ((start 0) match dir ret)
  524.     (setq env (concat (getenv env) path-separator))
  525.     (while (setq match (string-match path-separator env start))
  526.       (setq dir (substring env start match) start (1+ match))
  527.       ;;(and (file-directory-p dir) (not (member dir ret)) ...)
  528.       (setq ret (cons dir ret)))
  529.     (setq ret (nreverse ret))
  530.     (and empty (setq match (member "" ret))
  531.          (progn
  532.            (setcdr match (append (cdr-safe empty) (cdr match)))
  533.            (setcar match (or (car-safe empty) empty))))
  534.     ret)))
  535.  
  536. (defun ffap-reduce-path (path)
  537.   "Remove duplicates and non-directories from PATH list."
  538.   (let (ret tem)
  539.     (while path
  540.       (setq tem path path (cdr path))
  541.       (if (equal (car tem) ".") (setcar tem ""))
  542.       (or (member (car tem) ret)
  543.       (not (file-directory-p (car tem)))
  544.       (progn (setcdr tem ret) (setq ret tem))))
  545.     (nreverse ret)))
  546.  
  547. (defun ffap-add-subdirs (path)
  548.   "Return PATH augmented with its immediate subdirectories."
  549.   ;; (ffap-add-subdirs '("/notexist" "~"))
  550.   (let (ret subs)
  551.     (while path
  552.       (mapcar
  553.        (function
  554.     (lambda (f) (and (file-directory-p f) (setq ret (cons f ret)))))
  555.        (condition-case nil
  556.        (directory-files (car path) t "[^.]")
  557.      (error nil)))
  558.       (setq ret (cons (car path) ret)
  559.         path (cdr path)))
  560.     (nreverse ret)))
  561.  
  562. (defvar ffap-locate-jka-suffixes t
  563.   "List of compression suffixes tried by `ffap-locate-file'.
  564. If not a list, it is initialized by `ffap-locate-file',
  565. and it becomes nil unless you are using jka-compr.
  566. Typical values are nil or '(\".gz\" \".z\" \".Z\").")
  567.  
  568. (defun ffap-locate-file (file &optional nosuffix path)
  569.   "A generic path-searching function, mimics `load' by default.
  570. Returns path to file that \(load FILE\) would load, or nil.
  571. Optional NOSUFFIX, if nil or t, is like the fourth argument
  572. for load: whether to try the suffixes (\".elc\" \".el\" \"\").
  573. If a nonempty list, it is a list of suffixes to try instead.
  574. Optional PATH is a list of directories instead of `load-path'."
  575.   (or path (setq path load-path))
  576.   (if (file-name-absolute-p file)
  577.       (setq path (list (file-name-directory file))
  578.         file (file-name-nondirectory file)))
  579.   (let ((suffixes-to-try
  580.      (cond
  581.       ((consp nosuffix) nosuffix)
  582.       (nosuffix '(""))
  583.       (t '(".elc" ".el" "")))))
  584.     ;; Modern (>19.27) jka-compr doesn't try foo.gz when you want foo.
  585.     (or (listp ffap-locate-jka-suffixes)
  586.     (setq ffap-locate-jka-suffixes
  587.           (and (featurep 'jka-compr)
  588.            (not (featurep 'jka-aux))
  589.            jka-compr-file-name-handler-entry
  590.            (not (string-match
  591.              (car jka-compr-file-name-handler-entry)
  592.              "foo"))
  593.            ;; Hard to do this cleverly across jka-compr versions:
  594.            '(".gz" ".Z"))))
  595.     (if ffap-locate-jka-suffixes    ; so nil behaves like '("")
  596.     (setq suffixes-to-try
  597.           (apply
  598.            'nconc
  599.            (mapcar
  600.         (function
  601.          (lambda (suf)
  602.            (cons suf
  603.              (mapcar
  604.               (function (lambda (x) (concat suf x)))
  605.               ffap-locate-jka-suffixes))))
  606.         suffixes-to-try))))
  607.     (let (found suffixes)
  608.       (while (and path (not found))
  609.     (setq suffixes suffixes-to-try)
  610.     (while (and suffixes (not found))
  611.       (let ((try (expand-file-name
  612.               (concat file (car suffixes))
  613.               (car path))))
  614.         (if (and (file-exists-p try) (not (file-directory-p try)))
  615.         (setq found try)))
  616.       (setq suffixes (cdr suffixes)))
  617.     (setq path (cdr path)))
  618.       found)))
  619.  
  620. (defvar ffap-alist
  621.   ;; A big mess!  Parts are probably useless.
  622.   (list
  623.    (cons "\\.info\\'"
  624.      (defun ffap-info (name)
  625.        (ffap-locate-file
  626.         name '("" ".info")
  627.         (or (ffap-soft-value "Info-directory-list")
  628.         (ffap-soft-value "Info-default-directory-list")
  629.         ;; v18:
  630.         (list (ffap-soft-value "Info-directory" "~/info/"))))))
  631.    ;; Since so many info files do not have .info extension, also do this:
  632.    (cons "\\`info/"
  633.      (defun ffap-info-2 (name) (ffap-info (substring name 5))))
  634.    (cons "\\`[-a-z]+\\'"
  635.      ;; This ignores the node! "(emacs)Top" same as "(emacs)Intro"
  636.      (defun ffap-info-3 (name)
  637.        (and (equal (ffap-string-around) "()") (ffap-info name))))
  638.    (cons "\\.elc?\\'"
  639.      (defun ffap-el (name) (ffap-locate-file name t)))
  640.    (cons 'emacs-lisp-mode
  641.      (defun ffap-el-mode (name)
  642.        ;; We do not bother with "" here, since it was considered above.
  643.        ;; Also ignore "elc", for speed (who else reads elc files?)
  644.        (and (not (string-match "\\.el\\'" name))
  645.         (ffap-locate-file name '(".el")))))
  646.    '(finder-mode . ffap-el-mode)    ; v19: {C-h p}
  647.    '(help-mode . ffap-el-mode)        ; v19.29
  648.    (cons 'c-mode
  649.      (progn
  650.        ;; Need better defaults here!
  651.        (defvar ffap-c-path '("/usr/include" "/usr/local/include"))
  652.        (defun ffap-c-mode (name)
  653.          (ffap-locate-file name t ffap-c-path))))
  654.    '(c++-mode . ffap-c-mode)
  655.    '(cc-mode . ffap-c-mode)
  656.    '("\\.\\([chCH]\\|cc\\|hh\\)\\'" . ffap-c-mode)
  657.    (cons 'tex-mode
  658.      ;; Complicated because auctex may not be loaded yet.
  659.      (progn
  660.        (defvar ffap-tex-path
  661.          t                ; delayed initialization
  662.          "Path where `ffap-tex-mode' looks for tex files.
  663. If t, `ffap-tex-init' will initialize this when needed.")
  664.        (defun ffap-tex-init nil
  665.          ;; Compute ffap-tex-path if it is now t.
  666.          (and (eq t ffap-tex-path)
  667.           (message "Initializing ffap-tex-path ...")
  668.           (setq ffap-tex-path
  669.             (ffap-reduce-path
  670.              (append
  671.               (list ".")
  672.               (ffap-list-env "TEXINPUTS")
  673.               ;; (ffap-list-env "BIBINPUTS")
  674.               (ffap-add-subdirs
  675.                (ffap-list-env "TEXINPUTS_SUBDIR"
  676.                       (ffap-soft-value
  677.                        "TeX-macro-global"
  678.                        '("/usr/local/lib/tex/macros"
  679.                          "/usr/local/lib/tex/inputs")
  680.                        ))))))))
  681.        (defun ffap-tex-mode (name)
  682.          (ffap-tex-init)
  683.          (ffap-locate-file name '(".tex" "") ffap-tex-path))))
  684.    (cons 'latex-mode
  685.        (defun ffap-latex-mode (name)
  686.          (ffap-tex-init)
  687.          ;; Any real need for "" here?
  688.          (ffap-locate-file name '(".cls" ".sty" ".tex" "")
  689.                    ffap-tex-path)))
  690.    (cons "\\.\\(tex\\|sty\\|doc\\|cls\\)\\'"
  691.      (defun ffap-tex (name)
  692.        (ffap-tex-init)
  693.        (ffap-locate-file name t ffap-tex-path)))
  694.    (cons "\\.bib\\'"
  695.      (defun ffap-bib (name)
  696.        (ffap-locate-file
  697.         name t
  698.         (ffap-list-env "BIBINPUTS" '("/usr/local/lib/tex/macros/bib")))))
  699.    (cons 'math-mode
  700.      (defun ffap-math-mode (name)
  701.        (while (string-match "`" name)
  702.          (setq name (concat (substring name 0 (match-beginning 0))
  703.                 "/"
  704.                 (substring name (match-end 0)))))
  705.        (ffap-locate-file
  706.         name '(".m" "") (ffap-soft-value "Mathematica-search-path"))))
  707.    (cons "\\`\\." (defun ffap-home (name) (ffap-locate-file name t '("~"))))
  708.    (cons "\\`~/"
  709.      ;; Maybe a "Lisp Code Directory" reference:
  710.      (defun ffap-lcd (name)
  711.        (and
  712.         (or
  713.          ;; lisp-dir-apropos output buffer:
  714.          (string-match "Lisp Code Dir" (buffer-name))
  715.          ;; Inside an LCD entry like |~/misc/ffap.el.Z|,
  716.          ;; or maybe the holy LCD-Datafile itself:
  717.          (member (ffap-string-around) '("||" "|\n")))
  718.         (concat
  719.          ;; lispdir.el may not be loaded yet:
  720.          (ffap-host-to-path
  721.           (ffap-soft-value "elisp-archive-host"
  722.                    "archive.cis.ohio-state.edu"))
  723.          (file-name-as-directory
  724.           (ffap-soft-value "elisp-archive-directory"
  725.                    "/pub/gnu/emacs/elisp-archive/"))
  726.          (substring name 2)))))
  727.    (cons "^[Rr][Ff][Cc][- #]?\\([0-9]+\\)" ; no $
  728.      (progn
  729.        (defvar ffap-rfc-path
  730.          (concat (ffap-host-to-path "ds.internic.net") "/rfc/rfc%s.txt"))
  731.        (defun ffap-rfc (name)
  732.          (format ffap-rfc-path
  733.              (substring name (match-beginning 1) (match-end 1))))))
  734.    (cons "\\`[^/]*\\'"
  735.      (defun ffap-dired (name)
  736.        (let ((pt (point)) dir try)
  737.          (save-excursion
  738.            (and (progn
  739.               (beginning-of-line)
  740.               (looking-at " *[-d]r[-w][-x][-r][-w][-x][-r][-w][-x] "))
  741.             (re-search-backward "^ *$" nil t)
  742.             (re-search-forward "^ *\\([^ \t\n:]*\\):\n *total " pt t)
  743.             (file-exists-p
  744.              (setq try
  745.                (expand-file-name
  746.                 name
  747.                 (buffer-substring
  748.                  (match-beginning 1) (match-end 1)))))
  749.             try)))))
  750.    )
  751.   "Alist of \(KEY . FUNCTION\) pairs parsed by `ffap-file-at-point'.
  752. If string NAME at point (maybe \"\") is not a file or url, these pairs
  753. specify actions to try creating such a string.  A pair matches if either
  754.   KEY is a symbol, and it equals `major-mode', or
  755.   KEY is a string, it should matches NAME as a regexp.
  756. On a match, \(FUNCTION NAME\) is called and should return a file, an
  757. url, or nil. If nil, search the alist for further matches.")
  758.  
  759. (put 'ffap-alist 'risky-local-variable t)
  760.  
  761.  
  762. ;;; At-Point Functions:
  763.  
  764. (defvar ffap-string-at-point-mode-alist
  765.   '(
  766.     ;; The default, used when the `major-mode' is not found.
  767.     ;; Slightly controversial decisions:
  768.     ;; * strip trailing "@" and ":"
  769.     ;; * no commas (good for latex)
  770.     (file "--:$+<>@-Z_a-z~" "<@" "@>;.,!?:")
  771.     ;; An url, or maybe a email/news message-id:
  772.     (url "--:?$+@-Z_a-z~#,%" "^A-Za-z0-9" ":;.,!?")
  773.     ;; Find a string that does *not* contain a colon:
  774.     (nocolon "--9$+<>@-Z_a-z~" "<@" "@>;.,!?")
  775.     ;; A machine:
  776.     (machine "-a-zA-Z0-9." "" ".")
  777.     ;; Mathematica paths: allow backquotes
  778.     (math-mode ",-:$+<>@-Z_a-z~`" "<" "@>;.,!?`:")
  779.     )
  780.   "Alist of \(MODE CHARS BEG END\), where MODE is a symbol,
  781. possibly a `major-mode' or some symbol internal to ffap
  782. \(such as 'file, 'url, 'machine, and 'nocolon\).
  783. `ffap-string-at-point' uses the data fields as follows:
  784. 1. find a maximal string of CHARS around point,
  785. 2. strip BEG chars before point from the beginning,
  786. 3. Strip END chars after point from the end.")
  787.  
  788. (defvar ffap-string-at-point-region '(1 1)
  789.   "List (BEG END), last region returned by `ffap-string-at-point'.")
  790.  
  791. (defvar ffap-string-at-point nil
  792.   ;; Added at suggestion of RHOGEE (for ff-paths), 7/24/95.
  793.   "Last string returned by `ffap-string-at-point'.")
  794.  
  795. (defun ffap-string-at-point (&optional mode)
  796.   "Return a string of characters from around point.
  797. MODE (defaults to `major-mode') is a symbol used to lookup string
  798. syntax parameters in `ffap-string-at-point-mode-alist'.
  799. If MODE is not found, we fall back on the symbol 'file.
  800. Sets `ffap-string-at-point' and `ffap-string-at-point-region'."
  801.   (let* ((args
  802.       (cdr
  803.        (or (assq (or mode major-mode) ffap-string-at-point-mode-alist)
  804.            (assq 'file ffap-string-at-point-mode-alist))))
  805.      (pt (point))
  806.      (str
  807.       (buffer-substring
  808.        (save-excursion
  809.          (skip-chars-backward (car args))
  810.          (skip-chars-forward (nth 1 args) pt)
  811.          (setcar ffap-string-at-point-region (point)))
  812.        (save-excursion
  813.          (skip-chars-forward (car args))
  814.          (skip-chars-backward (nth 2 args) pt)
  815.          (setcar (cdr ffap-string-at-point-region) (point))))))
  816.     (or ffap-xemacs (set-text-properties 0 (length str) nil str))
  817.     (setq ffap-string-at-point str)))
  818.  
  819. (defun ffap-string-around nil
  820.   ;; Sometimes useful to decide how to treat a string.
  821.   "Return string of two chars around last `ffap-string-at-point'.
  822. Assumes the buffer has not changed."
  823.   (save-excursion
  824.     (format "%c%c"
  825.         (progn
  826.           (goto-char (car ffap-string-at-point-region))
  827.           (preceding-char))        ; maybe 0
  828.         (progn
  829.           (goto-char (nth 1 ffap-string-at-point-region))
  830.           (following-char))        ; maybe 0
  831.         )))
  832.  
  833. (defun ffap-copy-string-as-kill (&optional mode)
  834.   ;; Requested by MCOOK.  Useful?
  835.   "Call `ffap-string-at-point', and copy result to `kill-ring'."
  836.   (interactive)
  837.   (let ((str (ffap-string-at-point mode)))
  838.     (if (equal "" str)
  839.     (message "No string found around point.")
  840.       (kill-new str)
  841.       ;; Older: (apply 'copy-region-as-kill ffap-string-at-point-region)
  842.       (message "Copied to kill ring: %s"  str))))
  843.  
  844. (defun ffap-url-at-point nil
  845.   "Return url from around point if it exists, or nil."
  846.   ;; Could use w3's url-get-url-at-point instead.  Both handle "URL:",
  847.   ;; ignore non-relative links, trim punctuation.  The other will
  848.   ;; actually look back if point is in whitespace, but I would rather
  849.   ;; ffap be non-rabid in such situations.
  850.   (and
  851.    ffap-url-regexp
  852.    (or
  853.     ;; In a w3 buffer button zone?
  854.     (let (tem)
  855.       (and (eq major-mode 'w3-mode)
  856.        ;; assume: (boundp 'w3-zone-at) (boundp 'w3-zone-data)
  857.        (setq tem (w3-zone-at (point)))
  858.        (consp (setq tem (w3-zone-data tem)))
  859.        (nth 2 tem)))
  860.     ;; Is there a reason not to strip trailing colon?
  861.     (let ((name (ffap-string-at-point 'url)))
  862.       ;; (case-fold-search t), why?
  863.       (cond
  864.        ((string-match "^url:" name) (setq name (substring name 4)))
  865.        ((and (string-match "\\`[^:</>@]+@[^:</>@]+[a-zA-Z]\\'" name)
  866.          ;; "foo@bar": could be "mailto" or "news" (a Message-ID).
  867.          ;; If not adorned with "<>", it must be "mailto".
  868.          ;;    Otherwise could be either, so consult `ffap-foo-at-bar-prefix'.
  869.          (let ((prefix (if (and (equal (ffap-string-around) "<>")
  870.                     ;; At least a couple of odd characters:
  871.                     (string-match "[$.0-9].*[$.0-9].*@" name))
  872.                    ;; Could be news:
  873.                    ffap-foo-at-bar-prefix
  874.                  "mailto")))
  875.            (and prefix (setq name (concat prefix ":" name))))))
  876.        ((ffap-newsgroup-p name) (setq name (concat "news:" name)))
  877.        ((and (string-match "\\`[a-z0-9]+\\'" name) ; <mic> <root> <nobody>
  878.          (equal (ffap-string-around) "<>")
  879.          ;;    (ffap-user-p name):
  880.          (not (string-match "~" (expand-file-name (concat "~" name))))
  881.          )
  882.     (setq name (concat "mailto:" name)))
  883.        )
  884.       (and (ffap-url-p name) name)
  885.       ))))
  886.  
  887. (defvar ffap-gopher-regexp
  888.   "^.*\\<\\(Type\\|Name\\|Path\\|Host\\|Port\\) *= *\\(.*\\) *$"
  889.   "Regexp Matching a line in a gopher bookmark (maybe indented).
  890. The two subexpressions are the KEY and VALUE.")
  891.  
  892. (defun ffap-gopher-at-point nil
  893.   "If point is inside a gopher bookmark block, return its url."
  894.   ;; `gopher-parse-bookmark' from gopher.el is not so robust
  895.   (save-excursion
  896.     (beginning-of-line)
  897.     (if (looking-at ffap-gopher-regexp)
  898.     (progn
  899.       (while (and (looking-at ffap-gopher-regexp) (not (bobp)))
  900.         (forward-line -1))
  901.       (or (looking-at ffap-gopher-regexp) (forward-line 1))
  902.       (let ((type "1") name path host (port "70"))
  903.         (while (looking-at ffap-gopher-regexp)
  904.           (let ((var (intern
  905.               (downcase
  906.                (buffer-substring (match-beginning 1)
  907.                          (match-end 1)))))
  908.             (val (buffer-substring (match-beginning 2)
  909.                        (match-end 2))))
  910.         (set var val)
  911.         (forward-line 1)))
  912.         (if (and path (string-match "^ftp:.*@" path))
  913.         (concat "ftp://"
  914.             (substring path 4 (1- (match-end 0)))
  915.             (substring path (match-end 0)))
  916.           (and (= (length type) 1)
  917.            host;; (ffap-machine-p host)
  918.            (concat "gopher://" host
  919.                (if (equal port "70") "" (concat ":" port))
  920.                "/" type path))))))))
  921.  
  922. (defvar ffap-ftp-sans-slash-regexp
  923.   (and
  924.    ffap-ftp-regexp
  925.    ;; Note: by now, we know it is not an url.
  926.    ;; Icky regexp avoids: default: 123: foo::bar cs:pub
  927.    ;; It does match on: mic@cs: cs:/pub mathcs.emory.edu: (point at end)
  928.    "\\`\\([^:@]+@[^:@]+:\\|[^@.:]+\\.[^@:]+:\\|[^:]+:[~/]\\)\\([^:]\\|\\'\\)")
  929.   "Strings matching this are coerced to ftp paths by ffap.
  930. That is, ffap just prepends \"/\".  Set to nil to disable.")
  931.  
  932. (defun ffap-file-at-point nil
  933.   "Return filename from around point if it exists, or nil.
  934. Existence test is skipped for names that look remote.
  935. If the filename is not obvious, it also tries `ffap-alist',
  936. which may actually result in an url rather than a filename."
  937.   ;; Note: this function does not need to look for url's, just
  938.   ;; filenames.  On the other hand, it is responsible for converting
  939.   ;; a pseudo-url "site.com://path" to an ftp path
  940.   (let* ((case-fold-search t)        ; url prefixes are case-insensitive
  941.      (data (match-data))
  942.      (string (ffap-string-at-point)) ; uses mode alist
  943.      (name
  944.       (or (condition-case nil
  945.           (and (not (string-match "//" string)) ; foo.com://bar
  946.                (substitute-in-file-name string))
  947.         (error nil))
  948.           string))
  949.      (abs (file-name-absolute-p name))
  950.      (default-directory default-directory))
  951.     (unwind-protect
  952.     (cond
  953.      ;; Immediate rejects (/ and // are too common in C++):
  954.      ((member name '("" "/" "//")) nil)
  955.      ;; Immediately test local filenames.  If default-directory is
  956.      ;; remote, you probably already have a connection.
  957.      ((and (not abs) (ffap-file-exists-string name)))
  958.      ;; Accept remote names without actual checking (too slow):
  959.      ((if abs
  960.           (ffap-file-remote-p name)
  961.         ;; Try adding a leading "/" (common omission in ftp paths):
  962.         (and
  963.          ffap-ftp-sans-slash-regexp
  964.          (string-match ffap-ftp-sans-slash-regexp name)
  965.          (ffap-file-remote-p (concat "/" name)))))
  966.      ;; Ok, not remote, try the existence test even if it is absolute:
  967.      ((and abs (ffap-file-exists-string name)))
  968.      ;; If it contains a colon, get rid of it (and return if exists)
  969.      ((and (string-match path-separator name)
  970.            (setq name (ffap-string-at-point 'nocolon))
  971.            (ffap-file-exists-string name)))
  972.      ;; File does not exist, try the alist:
  973.      ((let ((alist ffap-alist) tem try case-fold-search)
  974.         (while (and alist (not try))
  975.           (setq tem (car alist) alist (cdr alist))
  976.           (if (or (eq major-mode (car tem))
  977.               (and (stringp (car tem))
  978.                (string-match (car tem) name)))
  979.           (and (setq try (funcall (cdr tem) name))
  980.                (setq try (or
  981.                   (ffap-url-p try) ; not a file!
  982.                   (ffap-file-remote-p try)
  983.                   (ffap-file-exists-string try))))))
  984.         try))
  985.      ;; Alist failed?  Try to guess an active remote connection
  986.      ;; from buffer variables, and try once more, both as an
  987.      ;; absolute and relative path on that remote host.
  988.      ((let* (ffap-rfs-regexp    ; suppress
  989.          (remote-dir
  990.           (cond
  991.            ((ffap-file-remote-p default-directory))
  992.            ((and (eq major-mode 'internal-ange-ftp-mode)
  993.              (string-match "^\\*ftp \\(.*\\)@\\(.*\\)\\*$"
  994.                        (buffer-name)))
  995.             (concat "/" (substring (buffer-name) 5 -1) ":"))
  996.            ;; This is too often a bad idea:
  997.            ;;((and (eq major-mode 'w3-mode)
  998.            ;;       (stringp url-current-server))
  999.            ;; (host-to-ange-path url-current-server))
  1000.            )))
  1001.         (and remote-dir
  1002.          (or
  1003.           (and (string-match "\\`\\(/?~?ftp\\)/" name)
  1004.                (ffap-file-exists-string
  1005.             (ffap-replace-path-component
  1006.              remote-dir (substring name (match-end 1)))))
  1007.           (ffap-file-exists-string
  1008.            (ffap-replace-path-component remote-dir name))))))
  1009.      )
  1010.       (store-match-data data))))
  1011.  
  1012.  
  1013. ;;; ffap-read-file-or-url:
  1014. ;;
  1015. ;; We want to complete filenames as in read-file-name, but also url's
  1016. ;; which read-file-name-internal would truncate at the "//" string.
  1017. ;; The solution here is to replace read-file-name-internal with
  1018. ;; `ffap-read-file-or-url-internal', which checks the minibuffer
  1019. ;; contents before attempting to complete filenames.
  1020.  
  1021. (defun ffap-read-file-or-url (prompt guess)
  1022.   "Read file or url from minibuffer, with PROMPT and initial GUESS."
  1023.   (or guess (setq guess default-directory))
  1024.   (let (dir)
  1025.     ;; Tricky: guess may have or be a local directory, like "w3/w3.elc"
  1026.     ;; or "w3/" or "../el/ffap.el" or "../../../"
  1027.     (or (ffap-url-p guess)
  1028.     (progn
  1029.       (or (ffap-file-remote-p guess)
  1030.           (setq guess (abbreviate-file-name (expand-file-name guess))))
  1031.       (setq dir (file-name-directory guess))))
  1032.     (setq guess
  1033.       (completing-read
  1034.        prompt
  1035.        'ffap-read-file-or-url-internal
  1036.        dir
  1037.        nil
  1038.        (if dir (cons guess (length dir)) guess)
  1039.        (list 'file-name-history)
  1040.        ))
  1041.     ;; Do file substitution like (interactive "F"), suggested by MCOOK.
  1042.     (or (ffap-url-p guess) (setq guess (substitute-in-file-name guess)))
  1043.     ;; Should not do it on url's, where $ is a common (VMS?) character.
  1044.     ;; Note: upcoming url.el package ought to handle this automatically.
  1045.     guess))
  1046.  
  1047. (defun ffap-read-url-internal (string dir action)
  1048.   "Complete url's from history, treating given string as valid."
  1049.   (let ((hist (ffap-soft-value "url-global-history-hash-table")))
  1050.     (cond
  1051.      ((not action)
  1052.       (or (try-completion string hist) string))
  1053.      ((eq action t)
  1054.       (or (all-completions string hist) (list string)))
  1055.      ;; action == lambda, documented where?  Tests whether string is a
  1056.      ;; valid "match".  Let us always say yes.
  1057.      (t t))))
  1058.  
  1059. (defun ffap-read-file-or-url-internal (string dir action)
  1060.   (if (ffap-url-p string)
  1061.       (ffap-read-url-internal string dir action)
  1062.     (read-file-name-internal string dir action)))
  1063.  
  1064. ;; The rest of this page is just to work with package complete.el.
  1065. ;; This code assumes that you load ffap.el after complete.el.
  1066. ;;
  1067. ;; We must inform complete about whether our completion function
  1068. ;; will do filename style completion.  For earlier versions of
  1069. ;; complete.el, this requires a defadvice.  For recent versions
  1070. ;; there may be a special variable for this purpose.
  1071.  
  1072. (defun ffap-complete-as-file-p nil
  1073.   ;; Will `minibuffer-completion-table' complete the minibuffer
  1074.   ;; contents as a filename?  Assumes the minibuffer is current.
  1075.   ;; Note: t and non-nil mean somewhat different reasons.
  1076.   (if (eq minibuffer-completion-table 'ffap-read-file-or-url-internal)
  1077.       (not (ffap-url-p (buffer-string))) ; t
  1078.     (memq minibuffer-completion-table
  1079.       '(read-file-name-internal read-directory-name-internal)) ; list
  1080.     ))
  1081.  
  1082. (and
  1083.  (featurep 'complete)
  1084.  (if (boundp 'PC-completion-as-file-name-predicate)
  1085.      ;; modern version of complete.el, just set the variable:
  1086.      (setq PC-completion-as-file-name-predicate 'ffap-complete-as-file-p)
  1087.    (require 'advice)
  1088.    (defadvice PC-do-completion (around ffap-fix act)
  1089.      "Work with ffap."
  1090.      (let ((minibuffer-completion-table
  1091.         (if (eq t (ffap-complete-as-file-p))
  1092.         'read-file-name-internal
  1093.           minibuffer-completion-table)))
  1094.        ad-do-it))))
  1095.  
  1096.  
  1097. ;;; Highlighting:
  1098. ;;
  1099. ;; Based on overlay highlighting in Emacs 19.28 isearch.el.
  1100.  
  1101. (defvar ffap-highlight (and window-system t)
  1102.   "If non-nil, ffap highlights the current buffer substring.")
  1103.  
  1104. (defvar ffap-highlight-overlay nil "Overlay used by `ffap-highlight'.")
  1105.  
  1106. (defun ffap-highlight (&optional remove)
  1107.   "If `ffap-highlight' is set, highlight the guess in this buffer.
  1108. That is, the last buffer substring found by `ffap-string-at-point'.
  1109. Optional argument REMOVE means to remove any such highlighting.
  1110. Uses the face `ffap' if it is defined, or else `highlight'."
  1111.   (cond
  1112.    (remove (and ffap-highlight-overlay (delete-overlay ffap-highlight-overlay)))
  1113.    ((not ffap-highlight) nil)
  1114.    (ffap-highlight-overlay
  1115.     (move-overlay ffap-highlight-overlay
  1116.           (car ffap-string-at-point-region)
  1117.           (nth 1 ffap-string-at-point-region)
  1118.           (current-buffer)))
  1119.    (t
  1120.     (setq ffap-highlight-overlay (apply 'make-overlay ffap-string-at-point-region))
  1121.     (overlay-put ffap-highlight-overlay 'face
  1122.          (if (internal-find-face 'ffap nil)
  1123.              'ffap 'highlight)))))
  1124.  
  1125.  
  1126. ;;; The big enchilada:
  1127.  
  1128. (defun ffap-guesser nil
  1129.   "Return file or url or nil, guessed from text around point."
  1130.   (or (and ffap-url-regexp
  1131.        (ffap-fixup-url (or (ffap-url-at-point)
  1132.                    (ffap-gopher-at-point))))
  1133.       (ffap-file-at-point)        ; may yield url!
  1134.       (ffap-fixup-machine (ffap-machine-at-point))))
  1135.  
  1136. (defun ffap-prompter (&optional guess)
  1137.   ;; Does guess and prompt step for find-file-at-point.
  1138.   ;; Extra complication for the temporary highlighting.
  1139.   (unwind-protect
  1140.       (ffap-read-file-or-url
  1141.        (if ffap-url-regexp "Find file or URL: " "Find file: ")
  1142.        (prog1
  1143.        (setq guess (or guess (ffap-guesser)))
  1144.      (and guess (ffap-highlight))
  1145.      ))
  1146.     (ffap-highlight t)))
  1147.  
  1148. ;;;###autoload
  1149. (defun find-file-at-point (&optional filename)
  1150.   "Find FILENAME (or url), guessing default from text around point.
  1151. If `ffap-dired-wildcards' is set, wildcard patterns are passed to dired.
  1152. See also the functions `ffap-file-at-point', `ffap-url-at-point'.
  1153. With a prefix, this command behaves *exactly* like `ffap-file-finder'.
  1154. If `ffap-require-prefix' is set, the prefix meaning is reversed.
  1155.  
  1156. See <ftp://ftp.mathcs.emory.edu/pub/mic/emacs/> for latest version."
  1157.   (interactive)
  1158.   (if (and (interactive-p)
  1159.        (if ffap-require-prefix (not current-prefix-arg)
  1160.          current-prefix-arg))
  1161.       ;; Do exactly the ffap-file-finder command, even the prompting:
  1162.       (let (current-prefix-arg)        ; we already interpreted it
  1163.     (call-interactively ffap-file-finder))
  1164.     (or filename (setq filename (ffap-prompter)))
  1165.     (cond
  1166.      ((ffap-url-p filename)
  1167.       (let (current-prefix-arg)        ; w3 2.3.25 bug, reported by KPC
  1168.     (funcall ffap-url-fetcher filename)))
  1169.      ;; This junk more properly belongs in a modified ffap-file-finder:
  1170.      ((and ffap-dired-wildcards
  1171.        (string-match ffap-dired-wildcards filename))
  1172.       (dired filename))
  1173.      ((or (not ffap-newfile-prompt)
  1174.       (file-exists-p filename)
  1175.       (y-or-n-p "File does not exist, create buffer? "))
  1176.       (funcall ffap-file-finder
  1177.            ;; expand-file-name fixes "~/~/.emacs" bug sent by CHUCKR.
  1178.            (expand-file-name filename)))
  1179.      ;; User does not want to find a non-existent file:
  1180.      ((signal 'file-error (list "Opening file buffer"
  1181.                 "no such file or directory"
  1182.                 filename))))))
  1183.  
  1184. ;; M-x shortcut:
  1185. ;;###autoload
  1186. (defalias 'ffap 'find-file-at-point)
  1187.  
  1188.  
  1189. ;;; Menu support:
  1190. ;;
  1191. ;; Bind ffap-menu to a key if you want, since it also works in tty mode.
  1192. ;; Or just use it through the ffap-at-mouse binding (next section).
  1193.  
  1194. (defvar ffap-menu-regexp nil
  1195.   "*If non-nil, overrides `ffap-next-regexp' during `ffap-menu'.
  1196. Make this more restrictive for faster menu building.
  1197. For example, try \":/\" for url (and some ftp) references.")
  1198.  
  1199. (defvar ffap-menu-alist nil
  1200.   "Buffer local cache of menu presented by `ffap-menu'.")
  1201. (make-variable-buffer-local 'ffap-menu-alist)
  1202.  
  1203. (defvar ffap-menu-text-plist
  1204.   (and window-system
  1205.        ;; These choices emulate goto-addr:
  1206.        (if ffap-xemacs
  1207.        '(face bold highlight t) ; keymap <map>
  1208.      '(face bold mouse-face highlight) ; keymap <mousy-map>
  1209.      ))
  1210.   "Text properties applied to strings found by `ffap-menu-rescan'.
  1211. These properties may be used to fontify the menu references.")
  1212.  
  1213. ;;;###autoload
  1214. (defun ffap-menu (&optional rescan)
  1215.   "Put up a menu of files and urls mentioned in this buffer.
  1216. Then set mark, jump to choice, and try to fetch it.  The menu is
  1217. cached in `ffap-menu-alist', and rebuilt by `ffap-menu-rescan'.
  1218. The optional RESCAN argument \(a prefix, interactively\) forces
  1219. a rebuild.  Searches with `ffap-menu-regexp'."
  1220.   (interactive "P")
  1221.   ;; (require 'imenu) -- no longer used, but roughly emulated
  1222.   (if (or (not ffap-menu-alist) rescan
  1223.       ;; or if the first entry is wrong:
  1224.       (and ffap-menu-alist
  1225.            (let ((first (car ffap-menu-alist)))
  1226.          (save-excursion
  1227.            (goto-char (cdr first))
  1228.            (not (equal (car first) (ffap-guesser)))))))
  1229.       (ffap-menu-rescan))
  1230.   ;; Tail recursive:
  1231.   (ffap-menu-ask
  1232.    (if ffap-url-regexp "Find file or URL" "Find file")
  1233.    (cons (cons "*Rescan Buffer*" -1) ffap-menu-alist)
  1234.    'ffap-menu-cont))
  1235.  
  1236. (defun ffap-menu-cont (choice)        ; continuation of ffap-menu
  1237.   (if (< (cdr choice) 0)
  1238.       (ffap-menu t)            ; *Rescan*
  1239.     (push-mark)
  1240.     (goto-char (cdr choice))
  1241.     ;; Momentary highlight:
  1242.     (unwind-protect
  1243.     (progn
  1244.       (and ffap-highlight (ffap-guesser) (ffap-highlight))
  1245.       (sit-for 0)            ; display
  1246.       (find-file-at-point (car choice)))
  1247.       (ffap-highlight t))))
  1248.  
  1249. (defun ffap-menu-ask (title alist cont)
  1250.   "Prompt from a menu of choices, and then apply some action.
  1251. Arguments are TITLE, ALIST, and CONT (a continuation).
  1252. This uses either a menu or the minibuffer depending on invocation.
  1253. The TITLE string is used as either the prompt or menu title.
  1254. Each \(string . data\) ALIST entry defines a choice \(data is ignored\).
  1255. Once the user makes a choice, function CONT is applied to the entry.
  1256. Always returns nil."
  1257.   ;; Bug: minibuffer prompting assumes the strings are unique.
  1258.   (let ((choice
  1259.      (if (and (fboundp 'x-popup-menu) ; Emacs 19 or XEmacs 19.13
  1260.           (boundp 'last-nonmenu-event) ; not in XEmacs 19.13
  1261.           (listp last-nonmenu-event))
  1262.          (x-popup-menu
  1263.           t
  1264.           (list ""
  1265.             (cons title
  1266.               (mapcar
  1267.                (function (lambda (i) (cons (car i) i)))
  1268.                alist))))
  1269.        ;; Immediately popup completion buffer:
  1270.        (prog1
  1271.            (let ((minibuffer-setup-hook 'minibuffer-completion-help))
  1272.          ;; BUG: this code assumes that "" is not a valid choice
  1273.          (completing-read
  1274.           (format "%s (default %s): " title (car (car alist)))
  1275.           alist nil t
  1276.           ;; (cons (car (car alist)) 0)
  1277.           nil
  1278.           ))
  1279.          ;; Redraw original screen:
  1280.          (sit-for 0)))))
  1281.     ;; Defaulting: convert "" to (car (car alist))
  1282.     (and (equal choice "") (setq choice (car (car alist))))
  1283.     (and (stringp choice) (setq choice (assoc choice alist)))
  1284.     (if choice (funcall cont choice) (message "No choice made!")))
  1285.   nil)                    ; return nothing
  1286.  
  1287. (defun ffap-menu-rescan nil
  1288.   "Search buffer for `ffap-menu-regexp' to build `ffap-menu-alist'.
  1289. Applies `ffap-menu-text-plist' text properties at all matches."
  1290.   (interactive)
  1291.   (let ((ffap-next-regexp (or ffap-menu-regexp ffap-next-regexp))
  1292.     (range (- (point-max) (point-min))) item
  1293.     buffer-read-only        ; to set text-properties
  1294.     ;; Avoid repeated searches of the *mode-alist:
  1295.     (major-mode (if (assq major-mode ffap-string-at-point-mode-alist)
  1296.             major-mode
  1297.               'file))
  1298.     )
  1299.     (setq ffap-menu-alist nil)
  1300.     (save-excursion
  1301.       (goto-char (point-min))
  1302.       (while (setq item (ffap-next-guess))
  1303.     (setq ffap-menu-alist (cons (cons item (point)) ffap-menu-alist))
  1304.     (add-text-properties (car ffap-string-at-point-region) (point)
  1305.                  ffap-menu-text-plist)
  1306.     (message "Scanning...%2d%% <%s>"
  1307.          (/ (* 100 (- (point) (point-min))) range) item))))
  1308.   (message "Scanning...done")
  1309.   ;; Remove duplicates.
  1310.   (setq ffap-menu-alist            ; sort by item
  1311.     (sort ffap-menu-alist
  1312.           (function
  1313.            (lambda (a b) (string-lessp (car a) (car b))))))
  1314.   (let ((ptr ffap-menu-alist))
  1315.     (while (cdr ptr)
  1316.       (if (equal (car (car ptr)) (car (car (cdr ptr))))
  1317.       (setcdr ptr (cdr (cdr ptr)))
  1318.     (setq ptr (cdr ptr)))))
  1319.   (setq ffap-menu-alist            ; sort by position
  1320.     (sort ffap-menu-alist
  1321.           (function
  1322.            (lambda (a b) (< (cdr a) (cdr b)))))))
  1323.  
  1324.  
  1325. ;;; Mouse Support:
  1326. ;;
  1327. ;; See the suggested binding in ffap-bindings (near eof).
  1328.  
  1329. (defvar ffap-at-mouse-fallback 'ffap-menu
  1330.   "Invoked by `ffap-at-mouse' if no file or url at click.
  1331. A command symbol, or nil for nothing.")
  1332. (put 'ffap-at-mouse-fallback 'risky-local-variable t)
  1333.  
  1334. (defun ffap-at-mouse (e)
  1335.   "Find file or url guessed from text around mouse point.
  1336. If none is found, call `ffap-at-mouse-fallback'."
  1337.   (interactive "e")
  1338.   (let ((guess
  1339.      ;; Maybe less surprising without the save-excursion?
  1340.      (save-excursion
  1341.        (mouse-set-point e)
  1342.        ;; Would like to do nothing unless click was *on* text.  How?
  1343.        ;; (cdr (posn-col-row (event-start e))) is always same as
  1344.        ;; current column.  For posn-x-y, need pixel-width!
  1345.        (ffap-guesser))))
  1346.     (cond
  1347.      (guess
  1348.       (ffap-highlight)
  1349.       (unwind-protect
  1350.       (progn
  1351.         (sit-for 0)            ; display
  1352.         (message "Guessing `%s'" guess)
  1353.         (find-file-at-point guess))
  1354.     (ffap-highlight t)))
  1355.      ((and (interactive-p)
  1356.        ffap-at-mouse-fallback)
  1357.       (call-interactively ffap-at-mouse-fallback))
  1358.      ((message "No file or URL found at mouse click.")))))
  1359.  
  1360.  
  1361. ;;; ffap-other-* commands
  1362. ;; Suggested by KPC.
  1363.  
  1364. (defun ffap-other-window nil
  1365.   "Like `ffap', but put buffer in another window."
  1366.   (interactive)
  1367.   (switch-to-buffer-other-window
  1368.    (save-window-excursion (call-interactively 'ffap) (current-buffer))))
  1369.  
  1370. (defun ffap-other-frame nil
  1371.   "Like `ffap', but put buffer in another frame."
  1372.   (interactive)
  1373.   (switch-to-buffer-other-frame
  1374.    (save-window-excursion (call-interactively 'ffap) (current-buffer))))
  1375.  
  1376.  
  1377. ;;; Bug Reporter:
  1378.  
  1379. (defun ffap-bug nil
  1380.   "Submit a bug report for the ffap package."
  1381.   ;; Important: keep the version string here in synch with that at top
  1382.   ;; of file!  Could use lisp-mnt from Emacs 19, but that would depend
  1383.   ;; on being able to find the ffap.el source file.
  1384.   (interactive)
  1385.   (require 'reporter)
  1386.   (let ((reporter-prompt-for-summary-p t))
  1387.     (reporter-submit-bug-report
  1388.      "Michelangelo Grigni <mic@mathcs.emory.edu>"
  1389.      "ffap 1.6"
  1390.      (mapcar 'intern (all-completions "ffap-" obarray 'boundp)))))
  1391.  
  1392. (fset 'ffap-submit-bug 'ffap-bug)    ; another likely name
  1393.  
  1394.  
  1395. ;;; Hooks for Gnus, VM, Rmail:
  1396. ;;
  1397. ;; If you do not like these bindings, write versions with whatever
  1398. ;; bindings you would prefer.
  1399.  
  1400. (defun ffap-ro-mode-hook nil
  1401.   "Bind `ffap-next' and `ffap-menu' to M-l and M-m, resp."
  1402.   (local-set-key "\M-l" 'ffap-next)
  1403.   (local-set-key "\M-m" 'ffap-menu)
  1404.   )
  1405.  
  1406. (defun ffap-gnus-hook nil
  1407.   "Bind `ffap-gnus-next' and `ffap-gnus-menu' to M-l and M-m, resp."
  1408.   (set (make-local-variable 'ffap-foo-at-bar-prefix) "news") ; message-id's
  1409.   ;; Note "l", "L", "m", "M" are taken:
  1410.   (local-set-key "\M-l" 'ffap-gnus-next)
  1411.   (local-set-key "\M-m" 'ffap-gnus-menu))
  1412.  
  1413. (defun ffap-gnus-wrapper (form)        ; used by both commands below
  1414.   (and (eq (current-buffer) (get-buffer gnus-summary-buffer))
  1415.        (gnus-summary-select-article))    ; get article of current line
  1416.   ;; Preserve selected buffer, but do not do save-window-excursion,
  1417.   ;; since we want to see any window created by the form.  Temporarily
  1418.   ;; select the article buffer, so we can see any point movement.
  1419.   (let ((sb (window-buffer (selected-window))))
  1420.     (gnus-configure-windows 'article)
  1421.     (pop-to-buffer gnus-article-buffer)
  1422.     (widen)
  1423.     ;; Skip headers for ffap-gnus-next (which will wrap around)
  1424.     (if (eq (point) (point-min)) (search-forward "\n\n" nil t))
  1425.     (unwind-protect
  1426.     (eval form)
  1427.       (pop-to-buffer sb))))
  1428.  
  1429. (defun ffap-gnus-next nil
  1430.   "Run `ffap-next' in the gnus article buffer."
  1431.   (interactive) (ffap-gnus-wrapper '(ffap-next nil t)))
  1432.  
  1433. (defun ffap-gnus-menu nil
  1434.   "Run `ffap-menu' in the gnus article buffer."
  1435.   (interactive) (ffap-gnus-wrapper '(ffap-menu)))
  1436.  
  1437.  
  1438. ;;; ffap-bindings: offer default global bindings
  1439.  
  1440. (defvar ffap-bindings
  1441.   (nconc
  1442.    (cond
  1443.     ((not (eq window-system 'x))
  1444.      nil)
  1445.     ;; GNU coding standards say packages should not bind S-mouse-*.
  1446.     ;; Is it ok to simply suggest such a binding to the user?
  1447.     (ffap-xemacs
  1448.      '((global-set-key '(shift button3) 'ffap-at-mouse)))
  1449.     (t
  1450.      '((global-set-key [S-down-mouse-3] 'ffap-at-mouse))))
  1451.    '(
  1452.      (global-set-key "\C-x\C-f" 'find-file-at-point)
  1453.      (global-set-key "\C-x4f"   'ffap-other-window)
  1454.      (global-set-key "\C-x5f"   'ffap-other-frame)
  1455.      (add-hook 'gnus-summary-mode-hook 'ffap-gnus-hook)
  1456.      (add-hook 'gnus-article-mode-hook 'ffap-gnus-hook)
  1457.      (add-hook 'vm-mode-hook 'ffap-ro-mode-hook)
  1458.      (add-hook 'rmail-mode-hook 'ffap-ro-mode-hook)
  1459.      ;; (setq dired-x-hands-off-my-keys t) ; the default
  1460.      ))
  1461.   "List of forms evaluated by function `ffap-bindings'.
  1462. A reasonable ffap installation needs just these two lines:
  1463.   (require 'ffap)
  1464.   (ffap-bindings)
  1465. These are only suggestions, they may be modified or ignored.")
  1466.  
  1467. (defun ffap-bindings nil
  1468.   "Evaluate the forms in variable `ffap-bindings'."
  1469.   (eval (cons 'progn ffap-bindings)))
  1470.  
  1471. ;; Example modifications:
  1472. ;;
  1473. ;; (setq ffap-alist                   ; remove a feature in `ffap-alist'
  1474. ;;     (delete (assoc 'c-mode ffap-alist) ffap-alist))
  1475. ;;
  1476. ;; (setq ffap-alist                   ; add something to `ffap-alist'
  1477. ;;     (cons
  1478. ;;      (cons "^[Yy][Ss][Nn][0-9]+$"
  1479. ;;        (defun ffap-ysn (name)
  1480. ;;          (concat
  1481. ;;           "http://snorri.chem.washington.edu/ysnarchive/issuefiles/"
  1482. ;;           (substring name 3) ".html")))
  1483. ;;      ffap-alist))
  1484.  
  1485.  
  1486. ;;; XEmacs:
  1487. ;; Extended suppport in another file, for copyright reasons.
  1488. (or (not ffap-xemacs)
  1489.     (load "ffap-xe" t t)
  1490.     (message "ffap warning: ffap-xe.el not found"))
  1491.  
  1492.  
  1493. ;;; ffap.el ends here
  1494.